#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>

#include "main.h"
#include "think.h"
#include "shared_memory.h"
#include "performConnection.h"
/*
 * Dieses Unterprogramm liest den derzeitigen Zustand des Spielfelds aus dem Shared-Memory
 * und stellt ihn menschenlesbar (ASCII) dar.
 */





void think(int shm_ID) {
        char* Schreibpuffer = malloc(20*sizeof(char));
        bzero(Schreibpuffer, 20);
        int i;
        SP *Info_lesen;
        Mein_Captured_Stein=0;
        Gegner_Captured_Stein=0;
        Mein_Available_Stein=0;
    	Gegner_Available_Stein=0;
        Initialisieren();

        /* SHM lesen und stein_position() rufen. */
       
        Info_lesen=shm_Segment_anbinden(shm_ID);
        if (Info_lesen[0].Flag==1) {       //Flag auswerten.
        /* Zu schlagenenden Stein bestimmen.*/
            for (i=0; i<18; i++) {
	            Stein_Position(Info_lesen[i].Spielernummer,Info_lesen[i].Position);
		        Info_lesen[i].Flag=0;     //Flag zurücksetzen.
	        }

	        if (Info_struct->capture==1){
		        SteinEntfernen1();
//              strcat(Schreibpuffer, "A0");
                strcat(Schreibpuffer, ZuSchlagendenStein->Eins->Name);
	        }

	        else if (Info_struct->capture==2){
		        SteinEntfernen2();
        	    strcat(Schreibpuffer, ZuSchlagendenStein->Eins->Name);
        	    strcat(Schreibpuffer, ";");
       		    strcat(Schreibpuffer, ZuSchlagendenStein->Zwei->Name);
	        }

	        else {

/* Spielfeld zeigen. */
        	    printf("Capture %d piece\n",Mein_Captured_Stein);
        	    for (i=0;i<=12;i++) {
                	printf("%s",Spielfeld[i]);
                }

/* Wenn alle Steine platziert sind, und es auf dem Spielfeld nur drei eigene Steine gibt. */

        	    if (Mein_Available_Stein==0&&Mein_Captured_Stein==6){
                	SpielzugBerechnenSpezial();
                	printf("Naechster Spielzug ist:\n");
                	printf("BeginnPosition: %s\n",NaechstenSpielzug->BeginnPosition->Name);
                	printf("EndPosition: %s\n",NaechstenSpielzug->EndPosition->Name);      
       		    }	

/* Wenn es auf dem Spielfeld mehr als drei eigene Steine gibt oder die Steine nicht alle platziert sind.*/

        	    else {
                	SteinZustandPruefen();
                	SpielzugBewerten();
                	SpielzugWaehlen();
                	printf("Naechster Spielzug ist:\n");
                	if (NaechstenSpielzug->BeginnPosition != NULL){
                        printf("BeginnPosition: %s\n",NaechstenSpielzug->BeginnPosition->Name);
                	}
                	printf("EndPosition: %s\n",NaechstenSpielzug->EndPosition->Name);      
        	    }

                if (NaechstenSpielzug->BeginnPosition != NULL){
                    strcat(Schreibpuffer, NaechstenSpielzug->BeginnPosition->Name);
                    strcat(Schreibpuffer, ":");
                }

                strcat(Schreibpuffer, NaechstenSpielzug->EndPosition->Name);
            }
    
    Info_struct->capture = 0;
    write(Info_struct->fd1, Schreibpuffer, strlen(Schreibpuffer));

    free(Schreibpuffer);
    free(Spielfeld);

   }
}

/* Spielfeld initialisieren. */
void Initialisieren()
{	
        if (MeinSpielerNummer==1){
                MeinZustand=2;
                GegnerZustand=1;
        }
        else{
                MeinZustand=1;
                GegnerZustand=2;
        }
	ZuSchlagendenStein=malloc(sizeof(struct SteinEntfern));
/* Alle Knoten des Spielbretts initialisieren. */

        int i,j,k;
        AlleKnoten=malloc(24*sizeof(struct Knoten*));
        for (i=0;i<24;i++){
                AlleKnoten[i]=malloc(sizeof(struct Knoten));
                AlleKnoten[i]->Zustand = 0;
                for (j=0;j<4;j++){
                        AlleKnoten[i]->Nachbar[j]=NULL;
                }
        }
        AlleKnoten[0]->Name="A0";
        AlleKnoten[0]->Nachbar[0]=AlleKnoten[1];//A1
        AlleKnoten[0]->Nachbar[1]=AlleKnoten[7];//A7
	AlleKnoten[0]->Muehle[0]=0;
	AlleKnoten[0]->Muehle[1]=3;
        AlleKnoten[1]->Name="A1";
        AlleKnoten[1]->Nachbar[0]=AlleKnoten[0];//A0
        AlleKnoten[1]->Nachbar[1]=AlleKnoten[2];//A2
        AlleKnoten[1]->Nachbar[2]=AlleKnoten[9];//B1
	AlleKnoten[1]->Muehle[0]=0;
	AlleKnoten[1]->Muehle[1]=12;
        AlleKnoten[2]->Name="A2";
        AlleKnoten[2]->Nachbar[0]=AlleKnoten[1];//A1
        AlleKnoten[2]->Nachbar[1]=AlleKnoten[3];//A3
	AlleKnoten[2]->Muehle[0]=0;
	AlleKnoten[2]->Muehle[1]=1;
        AlleKnoten[3]->Name="A3";
        AlleKnoten[3]->Nachbar[0]=AlleKnoten[2];//A2
        AlleKnoten[3]->Nachbar[1]=AlleKnoten[4];//A4
        AlleKnoten[3]->Nachbar[2]=AlleKnoten[11];//B3
	AlleKnoten[3]->Muehle[0]=1;
	AlleKnoten[3]->Muehle[1]=13;
        AlleKnoten[4]->Name="A4";
        AlleKnoten[4]->Nachbar[0]=AlleKnoten[3];//A3
        AlleKnoten[4]->Nachbar[1]=AlleKnoten[5];//A5
	AlleKnoten[4]->Muehle[0]=1;
	AlleKnoten[4]->Muehle[1]=2;
        AlleKnoten[5]->Name="A5";
        AlleKnoten[5]->Nachbar[0]=AlleKnoten[4];//A4
        AlleKnoten[5]->Nachbar[1]=AlleKnoten[6];//A6
        AlleKnoten[5]->Nachbar[2]=AlleKnoten[13];//B5
	AlleKnoten[5]->Muehle[0]=2;
	AlleKnoten[5]->Muehle[1]=14;
        AlleKnoten[6]->Name="A6";
        AlleKnoten[6]->Nachbar[0]=AlleKnoten[5];//A5
        AlleKnoten[6]->Nachbar[1]=AlleKnoten[7];//A7
	AlleKnoten[6]->Muehle[0]=2;
	AlleKnoten[6]->Muehle[1]=3;
        AlleKnoten[7]->Name="A7";
        AlleKnoten[7]->Nachbar[0]=AlleKnoten[0];//A0
        AlleKnoten[7]->Nachbar[1]=AlleKnoten[6];//A6
        AlleKnoten[7]->Nachbar[2]=AlleKnoten[15];//B7
	AlleKnoten[7]->Muehle[0]=3;
	AlleKnoten[7]->Muehle[1]=15;
        AlleKnoten[8]->Name="B0";
        AlleKnoten[8]->Nachbar[0]=AlleKnoten[9];//B1
        AlleKnoten[8]->Nachbar[1]=AlleKnoten[15];//B7
	AlleKnoten[8]->Muehle[0]=4;
	AlleKnoten[8]->Muehle[1]=7;
        AlleKnoten[9]->Name="B1";
        AlleKnoten[9]->Nachbar[0]=AlleKnoten[1];//A1
        AlleKnoten[9]->Nachbar[1]=AlleKnoten[8];//B0
        AlleKnoten[9]->Nachbar[2]=AlleKnoten[10];//B2
        AlleKnoten[9]->Nachbar[3]=AlleKnoten[17];//C1
	AlleKnoten[9]->Muehle[0]=4;
	AlleKnoten[9]->Muehle[1]=12;
        AlleKnoten[10]->Name="B2";
        AlleKnoten[10]->Nachbar[0]=AlleKnoten[9];//B1
        AlleKnoten[10]->Nachbar[1]=AlleKnoten[11];//B3
	AlleKnoten[10]->Muehle[0]=4;
	AlleKnoten[10]->Muehle[1]=5;
        AlleKnoten[11]->Name="B3";
        AlleKnoten[11]->Nachbar[0]=AlleKnoten[3];//A3
        AlleKnoten[11]->Nachbar[1]=AlleKnoten[10];//B2
        AlleKnoten[11]->Nachbar[2]=AlleKnoten[12];//B4
        AlleKnoten[11]->Nachbar[3]=AlleKnoten[19];//C3
	AlleKnoten[11]->Muehle[0]=5;
	AlleKnoten[11]->Muehle[1]=13;
        AlleKnoten[12]->Name="B4";
        AlleKnoten[12]->Nachbar[0]=AlleKnoten[11];//B3
        AlleKnoten[12]->Nachbar[1]=AlleKnoten[13];//B5
	AlleKnoten[12]->Muehle[0]=5;
	AlleKnoten[12]->Muehle[1]=6;
        AlleKnoten[13]->Name="B5";
        AlleKnoten[13]->Nachbar[0]=AlleKnoten[5];//A5
        AlleKnoten[13]->Nachbar[1]=AlleKnoten[12];//B4
        AlleKnoten[13]->Nachbar[2]=AlleKnoten[14];//B6
        AlleKnoten[13]->Nachbar[3]=AlleKnoten[21];//C5
	AlleKnoten[13]->Muehle[0]=6;
	AlleKnoten[13]->Muehle[1]=14;
        AlleKnoten[14]->Name="B6";
        AlleKnoten[14]->Nachbar[0]=AlleKnoten[13];//B5
        AlleKnoten[14]->Nachbar[1]=AlleKnoten[15];//B7
	AlleKnoten[14]->Muehle[0]=6;
	AlleKnoten[14]->Muehle[1]=7;
        AlleKnoten[15]->Name="B7";
        AlleKnoten[15]->Nachbar[0]=AlleKnoten[7];//A7
        AlleKnoten[15]->Nachbar[1]=AlleKnoten[8];//B0
        AlleKnoten[15]->Nachbar[2]=AlleKnoten[14];//B6
        AlleKnoten[15]->Nachbar[3]=AlleKnoten[23];//C7
	AlleKnoten[15]->Muehle[0]=7;
	AlleKnoten[15]->Muehle[1]=15;
        AlleKnoten[16]->Name="C0";
        AlleKnoten[16]->Nachbar[0]=AlleKnoten[17];//C1
        AlleKnoten[16]->Nachbar[1]=AlleKnoten[23];//C7
	AlleKnoten[16]->Muehle[0]=8;
	AlleKnoten[16]->Muehle[1]=11;
        AlleKnoten[17]->Name="C1";
        AlleKnoten[17]->Nachbar[0]=AlleKnoten[9];//B1
        AlleKnoten[17]->Nachbar[1]=AlleKnoten[16];//C0
        AlleKnoten[17]->Nachbar[2]=AlleKnoten[18];//C2
	AlleKnoten[17]->Muehle[0]=8;
	AlleKnoten[17]->Muehle[1]=12;
        AlleKnoten[18]->Name="C2";
        AlleKnoten[18]->Nachbar[0]=AlleKnoten[17];//C1
        AlleKnoten[18]->Nachbar[1]=AlleKnoten[19];//C3
	AlleKnoten[18]->Muehle[0]=8;
	AlleKnoten[18]->Muehle[1]=9;
        AlleKnoten[19]->Name="C3";
        AlleKnoten[19]->Nachbar[0]=AlleKnoten[11];//B3
        AlleKnoten[19]->Nachbar[1]=AlleKnoten[18];//C2
        AlleKnoten[19]->Nachbar[2]=AlleKnoten[20];//C4
	AlleKnoten[19]->Muehle[0]=9;
	AlleKnoten[19]->Muehle[1]=13;
        AlleKnoten[20]->Name="C4";
        AlleKnoten[20]->Nachbar[0]=AlleKnoten[19];//C3
        AlleKnoten[20]->Nachbar[1]=AlleKnoten[21];//C5
	AlleKnoten[20]->Muehle[0]=9;
	AlleKnoten[20]->Muehle[1]=10;
        AlleKnoten[21]->Name="C5";
        AlleKnoten[21]->Nachbar[0]=AlleKnoten[13];//B5
        AlleKnoten[21]->Nachbar[1]=AlleKnoten[20];//C4
        AlleKnoten[21]->Nachbar[2]=AlleKnoten[22];//C6
	AlleKnoten[21]->Muehle[0]=10;
	AlleKnoten[21]->Muehle[1]=14;
        AlleKnoten[22]->Name="C6";
        AlleKnoten[22]->Nachbar[0]=AlleKnoten[21];//C5
        AlleKnoten[22]->Nachbar[1]=AlleKnoten[23];//C7
	AlleKnoten[22]->Muehle[0]=10;
	AlleKnoten[22]->Muehle[1]=11;
        AlleKnoten[23]->Name="C7";
        AlleKnoten[23]->Nachbar[0]=AlleKnoten[15];//B7
        AlleKnoten[23]->Nachbar[1]=AlleKnoten[16];//C0
        AlleKnoten[23]->Nachbar[2]=AlleKnoten[22];//C6
	AlleKnoten[23]->Muehle[0]=11;
	AlleKnoten[23]->Muehle[1]=15;

/* Muehlelinie initialisieren */
       
        Muehlelinie=malloc(16*(sizeof(struct Knoten**)));
        for (i=0;i<16;i++){
                Muehlelinie[i]=malloc(3*(sizeof(struct Knoten*)));
        }
        Muehlelinie[0][0]=AlleKnoten[0];        
        Muehlelinie[0][1]=AlleKnoten[1];        
        Muehlelinie[0][2]=AlleKnoten[2];//A0A1A2
        Muehlelinie[1][0]=AlleKnoten[2];        
        Muehlelinie[1][1]=AlleKnoten[3];        
        Muehlelinie[1][2]=AlleKnoten[4];//A2A3A4
        Muehlelinie[2][0]=AlleKnoten[4];        
        Muehlelinie[2][1]=AlleKnoten[5];        
        Muehlelinie[2][2]=AlleKnoten[6];//A4A5A6
        Muehlelinie[3][0]=AlleKnoten[6];        
        Muehlelinie[3][1]=AlleKnoten[7];        
        Muehlelinie[3][2]=AlleKnoten[0];//A6A7A0
        Muehlelinie[4][0]=AlleKnoten[8];        
        Muehlelinie[4][1]=AlleKnoten[9];        
        Muehlelinie[4][2]=AlleKnoten[10];//B0B1B2
        Muehlelinie[5][0]=AlleKnoten[10];      
        Muehlelinie[5][1]=AlleKnoten[11];      
        Muehlelinie[5][2]=AlleKnoten[12];//B2B3B4
        Muehlelinie[6][0]=AlleKnoten[12];      
        Muehlelinie[6][1]=AlleKnoten[13];      
        Muehlelinie[6][2]=AlleKnoten[14];//B4B5B6
        Muehlelinie[7][0]=AlleKnoten[14];      
        Muehlelinie[7][1]=AlleKnoten[15];      
        Muehlelinie[7][2]=AlleKnoten[8];//B6B7B0
        Muehlelinie[8][0]=AlleKnoten[16];      
        Muehlelinie[8][1]=AlleKnoten[17];      
        Muehlelinie[8][2]=AlleKnoten[18];//C0C1C2
        Muehlelinie[9][0]=AlleKnoten[18];      
        Muehlelinie[9][1]=AlleKnoten[19];      
        Muehlelinie[9][2]=AlleKnoten[20];//C2C3C4
        Muehlelinie[10][0]=AlleKnoten[20];      
        Muehlelinie[10][1]=AlleKnoten[21];      
        Muehlelinie[10][2]=AlleKnoten[22];//C4C5C6
        Muehlelinie[11][0]=AlleKnoten[22];      
        Muehlelinie[11][1]=AlleKnoten[23];      
        Muehlelinie[11][2]=AlleKnoten[16];//C6C7C0
        Muehlelinie[12][0]=AlleKnoten[1];      
        Muehlelinie[12][1]=AlleKnoten[9];      
        Muehlelinie[12][2]=AlleKnoten[17];//A1B1C1
        Muehlelinie[13][0]=AlleKnoten[3];      
        Muehlelinie[13][1]=AlleKnoten[11];      
        Muehlelinie[13][2]=AlleKnoten[19];//A3B3C3
        Muehlelinie[14][0]=AlleKnoten[5];      
        Muehlelinie[14][1]=AlleKnoten[13];      
        Muehlelinie[14][2]=AlleKnoten[21];//A5B5C5
        Muehlelinie[15][0]=AlleKnoten[7];      
        Muehlelinie[15][1]=AlleKnoten[15];      
        Muehlelinie[15][2]=AlleKnoten[23];//A7B7C7
       
/* Spielzug initialisieren. */
        NachbarnSumme=0;
        for (i=0;i<24;i++){
                NachbarvonKnoten[i]=0;
        }
        for (i=0;i<24;i++){
                for (j=0;j<4;j++){
                        if (AlleKnoten[i]->Nachbar[j]!=NULL){
                                NachbarnSumme++;
                                NachbarvonKnoten[i]++;
                        }
                }
        }
        AlleSpielzug=malloc((24+NachbarnSumme)*sizeof(struct Spielzug*));
        for (i=0;i<24+NachbarnSumme;i++){
                AlleSpielzug[i]=malloc(sizeof(struct Spielzug));
                AlleSpielzug[i]->Bewertung=0;
                AlleSpielzug[i]->WahlHilfe=-1;
        }
        for (i=0;i<24;i++){
                AlleSpielzug[i]->BeginnPosition=NULL;
                AlleSpielzug[i]->EndPosition=AlleKnoten[i];
        }
        k=24;
        for (i=0;i<24;i++){
                for (j=0;j<NachbarvonKnoten[i];j++){
                        AlleSpielzug[k]->BeginnPosition=AlleKnoten[i];
                        AlleSpielzug[k]->EndPosition=AlleKnoten[i]->Nachbar[j];
                        k++;
                }
        }

/* Zu schlagenden Steine initialisieren.*/

        AlleZSStein=malloc(24*24*sizeof(struct SteinEntfern*));
        for (i=0;i<24*24;i++){
                AlleZSStein[i]=malloc(sizeof(struct SteinEntfern));
        }
        for (i=0;i<24;i++){
                for (j=0;j<24;j++){
                        AlleZSStein[i*24+j]->Eins=AlleKnoten[i];
                        AlleZSStein[i*24+j]->Zwei=AlleKnoten[j];
                        AlleZSStein[i*24+j]->Bewertung=0;
                        AlleZSStein[i*24+j]->WahlHilfe=0;
                }
        }


/*Spielfeld initialisieren*/

        Spielfeld=(char**)malloc(13*sizeof(char*));
        for(i=0;i<=12;i++) {
                Spielfeld[i]=(char*)malloc(28*sizeof(char));
        }
        Spielfeld[0][0]=' ';
        Spielfeld[0][1]='+';
        for (i=2;i<=12;i++) {
                Spielfeld[0][i]='-';
        }
        Spielfeld[0][13]='+';
        for (i=14;i<=24;i++) {
                Spielfeld[0][i]='-';
        }
        Spielfeld[0][25]='+';
        Spielfeld[0][26]=' ';
        Spielfeld[0][27]='\n';
        Spielfeld[1] =" |           |           | \n";
        Spielfeld[2][0]=' ';
        Spielfeld[2][1]='|';
        for (i=2;i<=4;i++) {
                Spielfeld[2][i]=' ';
        }
        Spielfeld[2][5]='+';
        for (i=6;i<=12;i++) {
                Spielfeld[2][i]='-';
        }
        Spielfeld[2][13]='+';
        for (i=14;i<=20;i++) {
                Spielfeld[2][i]='-';
        }
        Spielfeld[2][21]='+';
        for (i=22;i<=24;i++) {
                Spielfeld[2][i]=' ';
        }
        Spielfeld[2][25]='|';
        Spielfeld[2][26]=' ';
        Spielfeld[2][27]='\n';
        Spielfeld[3] =" |   |       |       |   | \n";
        Spielfeld[4][0]=' ';
        Spielfeld[4][1]='|';
        for (i=2;i<=4;i++) {
                Spielfeld[4][i]=' ';
        }
        Spielfeld[4][5]='|';
        for (i=6;i<=8;i++) {
                Spielfeld[4][i]=' ';
        }
        Spielfeld[4][9]='+';
        for (i=10;i<=12;i++) {
                Spielfeld[4][i]='-';
        }
        Spielfeld[4][13]='+';
        for (i=14;i<=16;i++) {
                Spielfeld[4][i]='-';
        }
        Spielfeld[4][17]='+';
        for (i=18;i<=20;i++) {
                Spielfeld[4][i]=' ';
        }
        Spielfeld[4][21]='|';
        for (i=22;i<=24;i++){
                Spielfeld[4][i]=' ';
        }
        Spielfeld[4][25]='|';
        Spielfeld[4][26]=' ';
        Spielfeld[4][27]='\n';
        Spielfeld[5] =" |   |   |       |   |   | \n";
        Spielfeld[6][0]=' ';
        Spielfeld[6][1]='+';
        for (i=2;i<=4;i++) {
                Spielfeld[6][i]='-';
        }
        Spielfeld[6][5]='+';
        for (i=6;i<=8;i++) {
                Spielfeld[6][i]='-';
        }
        Spielfeld[6][9]='+';
        for (i=10;i<=16;i++) {
                Spielfeld[6][i]=' ';
        }
        Spielfeld[6][17]='+';
        for (i=18;i<=20;i++) {
                Spielfeld[6][i]='-';
        }
        Spielfeld[6][21]='+';
        for (i=22;i<=24;i++) {
                Spielfeld[6][i]='-';
        }
        Spielfeld[6][25]='+';
        Spielfeld[6][26]=' ';
        Spielfeld[6][27]='\n';
        Spielfeld[7] =" |   |   |       |   |   | \n";
        Spielfeld[8][0]=' ';
        Spielfeld[8][1]='|';
        for (i=2;i<=4;i++) {
                Spielfeld[8][i]=' ';
        }
        Spielfeld[8][5]='|';
        for (i=6;i<=8;i++) {
                Spielfeld[8][i]=' ';
        }
        Spielfeld[8][9]='+';
        for (i=10;i<=12;i++) {
                Spielfeld[8][i]='-';
        }
        Spielfeld[8][13]='+';
        for (i=14;i<=16;i++) {
                Spielfeld[8][i]='-';
        }
        Spielfeld[8][17]='+';
        for (i=18;i<=20;i++) {
                Spielfeld[8][i]=' ';
        }
        Spielfeld[8][21]='|';
        for (i=22;i<=24;i++) {
                Spielfeld[8][i]=' ';
        }
        Spielfeld[8][25]='|';
        Spielfeld[8][26]=' ';
        Spielfeld[8][27]='\n';
        Spielfeld[9] =" |   |       |       |   | \n";
        Spielfeld[10][0]=' ';
        Spielfeld[10][1]='|';
        for (i=2;i<=4;i++) {
                Spielfeld[10][i]=' ';
        }
        Spielfeld[10][5]='+';
        for (i=6;i<=12;i++) {
                Spielfeld[10][i]='-';
        }
        Spielfeld[10][13]='+';
        for (i=14;i<=20;i++) {
                Spielfeld[10][i]='-';
        }
        Spielfeld[10][21]='+';
        for (i=22;i<=24;i++) {
                Spielfeld[10][i]=' ';
        }
        Spielfeld[10][25]='|';
        Spielfeld[10][26]=' ';
        Spielfeld[10][27]='\n';
        Spielfeld[11]=" |           |           | \n";
        Spielfeld[12][0]=' ';
        Spielfeld[12][1]='+';
        for (i=2;i<=12;i++) {
                Spielfeld[12][i]='-';
        }
        Spielfeld[12][13]='+';
        for (i=14;i<=24;i++) {
                Spielfeld[12][i]='-';
        }
        Spielfeld[12][25]='+';
        Spielfeld[12][26]=' ';
        Spielfeld[12][27]='\n';
}

/* Die Position vom Stein auf dem Spielfeld zeigen. */
void Stein_Position(int Spielernummer, char* Position)
{      
/* Die Typ vom Stein nach der Spielernummer entscheiden. */
        if (Spielernummer==01) {
                Stein='*';
        }
        else {
                Stein='#';
        }
/* Wenn Position='A'||'C', wird das Spielfeld nicht verändert. */
/* '+' nach der Positionsinfo durch Steinsymbol ersetzen. */
        if (strcmp(Position, "A0")==0) {
                Spielfeld[0][0]='(';
                Spielfeld[0][1]=Stein;
                Spielfeld[0][2]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[0]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[0]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A1")==0) {
                Spielfeld[0][12]='(';
                Spielfeld[0][13]=Stein;
                Spielfeld[0][14]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[1]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[1]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A2")==0) {
                Spielfeld[0][24]='(';
                Spielfeld[0][25]=Stein;
                Spielfeld[0][26]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[2]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[2]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B0")==0) {
                Spielfeld[2][4]='(';
                Spielfeld[2][5]=Stein;
                Spielfeld[2][6]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[8]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[8]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B1")==0) {
                Spielfeld[2][12]='(';
                Spielfeld[2][13]=Stein;
                Spielfeld[2][14]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[9]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[9]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B2")==0) {
                Spielfeld[2][20]='(';
                Spielfeld[2][21]=Stein;
                Spielfeld[2][22]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[10]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[10]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C0")==0) {
                Spielfeld[4][8]='(';
                Spielfeld[4][9]=Stein;
                Spielfeld[4][10]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[16]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[16]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C1")==0) {
                Spielfeld[4][12]='(';
                Spielfeld[4][13]=Stein;
                Spielfeld[4][14]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[17]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[17]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C2")==0) {
                Spielfeld[4][16]='(';
                Spielfeld[4][17]=Stein;
                Spielfeld[4][18]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[18]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[18]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A7")==0) {
                Spielfeld[6][0]='(';
                Spielfeld[6][1]=Stein;
                Spielfeld[6][2]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[7]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[7]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B7")==0) {
                Spielfeld[6][4]='(';
                Spielfeld[6][5]=Stein;
                Spielfeld[6][6]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[15]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[15]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C7")==0) {
                Spielfeld[6][8]='(';
                Spielfeld[6][9]=Stein;
                Spielfeld[6][10]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[23]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[23]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C3")==0) {
                Spielfeld[6][16]='(';
                Spielfeld[6][17]=Stein;
                Spielfeld[6][18]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[19]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[19]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B3")==0) {
                Spielfeld[6][20]='(';
                Spielfeld[6][21]=Stein;
                Spielfeld[6][22]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[11]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[11]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A3")==0) {
                Spielfeld[6][24]='(';
                Spielfeld[6][25]=Stein;
                Spielfeld[6][26]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[3]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[3]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C6")==0) {
                Spielfeld[8][8]='(';
                Spielfeld[8][9]=Stein;
                Spielfeld[8][10]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[22]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[22]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C5")==0) {
                Spielfeld[8][12]='(';
                Spielfeld[8][13]=Stein;
                Spielfeld[8][14]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[21]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[21]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "C4")==0) {
                Spielfeld[8][16]='(';
                Spielfeld[8][17]=Stein;
                Spielfeld[8][18]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[20]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[20]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B6")==0) {
                Spielfeld[10][4]='(';
                Spielfeld[10][5]=Stein;
                Spielfeld[10][6]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[14]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[14]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B5")==0) {
                Spielfeld[10][12]='(';
                Spielfeld[10][13]=Stein;
                Spielfeld[10][14]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[13]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[13]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "B4")==0) {
                Spielfeld[10][20]='(';
                Spielfeld[10][21]=Stein;
                Spielfeld[10][22]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[12]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[12]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A6")==0) {
                Spielfeld[12][0]='(';
                Spielfeld[12][1]=Stein;
                Spielfeld[12][2]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[6]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[6]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A5")==0) {
                Spielfeld[12][12]='(';
                Spielfeld[12][13]=Stein;
                Spielfeld[12][14]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[5]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[5]->Zustand=MeinZustand;
                }
        }
        else if (strcmp(Position, "A4")==0) {
                Spielfeld[12][24]='(';
                Spielfeld[12][25]=Stein;
                Spielfeld[12][26]=')';
                if (Spielernummer==MeinSpielerNummer) {
                        AlleKnoten[4]->Zustand=GegnerZustand;
                }
                else{
                        AlleKnoten[4]->Zustand=MeinZustand;
                }
        }
        else if (strstr(Position, "A")!=NULL) {
                if (Spielernummer==MeinSpielerNummer){
                        Gegner_Available_Stein++;
                }
                else{
                        Mein_Available_Stein++;
                }
        }
        else if (strstr(Position, "C")!=NULL) {
                if (Spielernummer==MeinSpielerNummer){
                        Gegner_Captured_Stein++;
                }
                else{
                        Mein_Captured_Stein++;
                }
        }
        else {
                fprintf(stderr, "Ungültige Position.\n");
        }
}

/* Berechne, wie viele Knoten in einer Muehlelinie schon von einem Stein bestetzt sind. */

void MuehleZustandBerechnen(){
        int i,j;
        for (i=0;i<16;i++){
                for (j=0;j<3;j++){
                        if(Muehlelinie[i][j]->Zustand!=0){
                                MuehleZustand[i]++;
                        }
                }
        }
        for (i=0;i<16;i++){
                for (j=0;j<3;j++){
                        if(Muehlelinie[i][j]->Zustand==MeinZustand){
                                MeinMuehleZustand[i]++;
                        }
                }
        }
        for (i=0;i<16;i++){
                for (j=0;j<3;j++){
                        if(Muehlelinie[i][j]->Zustand==GegnerZustand){
                                GegnerMuehleZustand[i]++;
                        }
                }
        }
}



/* Zustand der Muehlelinie zuruecksetzen. */

void MuehleZustandZurueckSetzen(){
        int i;
        for (i=0;i<16;i++){
                MuehleZustand[i]=0;
		MeinMuehleZustand[i]=0;
		GegnerMuehleZustand[i]=0;
        }
}

/* Bewerte alle moegliche Spielzuege */

void SpielzugBewerten(){
        int i,j,h,k;
	int MuehleVIP[4];
	for (i=0;i<4;i++){
		MuehleVIP[i]=0;
	}

/* Wenn die EndPosition eines Spielzugs nicht leer ist, setze diesen Spielzug als ungueltig.  */

        for (i=0;i<24+NachbarnSumme;i++){
                if (AlleSpielzug[i]->EndPosition->Zustand!=0){
                        AlleSpielzug[i]->Bewertung=-1000;
                }
        }
	for (i=0;i<24;i++){
		if (Mein_Available_Stein==0){
                        AlleSpielzug[i]->Bewertung=-1000;
		}
	}
/* Berechne die Zustandaenderungen von den Muehlelinien, wenn man einen neuen Stein auf das Spielfeld legt.  */


        for (i=0;i<24;i++){
                if (AlleSpielzug[i]->Bewertung==-1000){
                        continue;
                }
                else{
                        AlleSpielzug[i]->EndPosition->Zustand=MeinZustand;
                        MuehleZustandZurueckSetzen();
                        MuehleZustandBerechnen();
			MuehleVIP[0]=AlleSpielzug[i]->EndPosition->Muehle[0];
			MuehleVIP[1]=AlleSpielzug[i]->EndPosition->Muehle[1];
			for (j=0;j<2;j++){
                        	if (MeinMuehleZustand[MuehleVIP[j]]==3){
					AlleSpielzug[i]->Bewertung+=50;
				}
				else if (GegnerMuehleZustand[MuehleVIP[j]]==2&&MuehleZustand[MuehleVIP[j]]==3){
                                        AlleSpielzug[i]->Bewertung+=10;
                                }
				else if (MeinMuehleZustand[MuehleVIP[j]]==2&&GegnerMuehleZustand[MuehleVIP[j]]==0){
					AlleSpielzug[i]->Bewertung+=2;	
				}
				else if (MeinMuehleZustand[MuehleVIP[j]]==1&&GegnerMuehleZustand[MuehleVIP[j]]==0){
					AlleSpielzug[i]->Bewertung+=1;	
				}
				else if (MeinMuehleZustand[MuehleVIP[j]]==1&&GegnerMuehleZustand[MuehleVIP[j]]==1){
					AlleSpielzug[i]->Bewertung-=1;	
				}
                                else{
                                        continue;
                                }
			}
                        AlleSpielzug[i]->EndPosition->Zustand=0;
                }
                
        }


/* Berechne die Zustandaenderungen von den Muehlelinie, wenn man mit einem eigenen Stein auf seinen Nachbar ziehen */
        k=24;
        for (i=0;i<24;i++){
                if (AlleSpielzug[k]->BeginnPosition->Zustand!=MeinZustand){
                    for (j=0;j<NachbarvonKnoten[i];j++){
                        AlleSpielzug[k+j]->Bewertung=-1000;
                    }
                    k=k+NachbarvonKnoten[i];
                    continue;
                }
                else{
                        for (j=0;j<NachbarvonKnoten[i];j++){
				if(AlleSpielzug[k]->EndPosition->Zustand!=0){
					AlleSpielzug[k]->Bewertung=-1000;
				}
				else{
					AlleSpielzug[k]->BeginnPosition->Zustand=0;
					AlleSpielzug[k]->EndPosition->Zustand=MeinZustand;
					MuehleZustandZurueckSetzen();
					MuehleZustandBerechnen();
					MuehleVIP[0]=AlleSpielzug[k]->BeginnPosition->Muehle[0];
					MuehleVIP[1]=AlleSpielzug[k]->BeginnPosition->Muehle[1];
					MuehleVIP[2]=AlleSpielzug[k]->EndPosition->Muehle[0];
					MuehleVIP[3]=AlleSpielzug[k]->EndPosition->Muehle[1];
					for (h=2;h<4;h++){
					if (MeinMuehleZustand[MuehleVIP[h]]==3){
						AlleSpielzug[k]->Bewertung+=50;
					}
					else if (GegnerMuehleZustand[MuehleVIP[h]]==2&&MuehleZustand[MuehleVIP[h]]==3){
						AlleSpielzug[k]->Bewertung+=10;
					}
					else if (MeinMuehleZustand[MuehleVIP[h]]==2&&GegnerMuehleZustand[MuehleVIP[h]]==0){
						AlleSpielzug[k]->Bewertung+=2;	
					}
					else if (MeinMuehleZustand[MuehleVIP[h]]==1&&GegnerMuehleZustand[MuehleVIP[h]]==0){
						AlleSpielzug[k]->Bewertung+=1;	
					}
					else{
						continue;
					}
					}
					for (h=0;h<2;h++){
					if (GegnerMuehleZustand[MuehleVIP[h]]==2&&MuehleZustand[MuehleVIP[h]]==2){
						AlleSpielzug[k]->Bewertung-=10;
					}
					else if (MeinMuehleZustand[MuehleVIP[h]]==1&&GegnerMuehleZustand[MuehleVIP[h]]==0){
					AlleSpielzug[k]->Bewertung-=2;	
					}
					else if (MeinMuehleZustand[MuehleVIP[h]]==1&&GegnerMuehleZustand[MuehleVIP[h]]==0){
						AlleSpielzug[k]->Bewertung-=1;	
					}
					else{
						continue;
					}
					}
					AlleSpielzug[k]->BeginnPosition->Zustand=MeinZustand;
					AlleSpielzug[k]->EndPosition->Zustand=0;
				}
				k++;
                        }
                }
        }

}

/* Spielzug mit hoechster Bewertung waehlen.*/
void SpielzugWaehlen(){
        int i,j,WahlNummer;
        j=0;
        BestBewertung=AlleSpielzug[0]->Bewertung;
        for (i=0;i<24+NachbarnSumme;i++){
                if (AlleSpielzug[i]->Bewertung>BestBewertung){
                        BestBewertung=AlleSpielzug[i]->Bewertung;
                }
        }
        for (i=0;i<24+NachbarnSumme;i++){
                if (AlleSpielzug[i]->Bewertung==BestBewertung){
                        AlleSpielzug[i]->WahlHilfe=j;
                        j++;
                }      
        }
       
       
        srand(time(NULL));
        WahlNummer=rand()%j;
        for (i=0;i<24+NachbarnSumme;i++){
                if (AlleSpielzug[i]->WahlHilfe==WahlNummer){
                        NaechstenSpielzug=AlleSpielzug[i];
                }
        }
}

/* Pruefe, ob alle 9 Steine schon auf dem Spielfeld liegen. */

void SteinZustandPruefen(){
        int i;
        if (Mein_Available_Stein>0){
                for (i=24;i<24+NachbarnSumme;i++){
                        AlleSpielzug[i]->Bewertung=-1000;
                }
        }
}

void SpielzugBerechnenSpezial(){
        SpielzugSpezial=malloc((24*24)*sizeof(struct Spielzug*));
        int i,j,h,Zustand_temp,WahlNummer;
        for (i=0; i<24*24;i++){
            SpielzugSpezial[i] = malloc(sizeof(struct Spielzug));
        }
	int MuehleVIP[4];

/* Spielzug initialisieren. Alle Knoten kann man als Beginnposition waehlen und Alle andere Knoten kann man als Endposition waehlen. */

        for (i=0;i<24;i++){
                for (j=0;j<24;j++){
                        SpielzugSpezial[i*24+j]->BeginnPosition=AlleKnoten[i];
                        SpielzugSpezial[i*24+j]->EndPosition=AlleKnoten[j];
                        SpielzugSpezial[i*24+j]->Bewertung=0;
                        SpielzugSpezial[i*24+j]->WahlHilfe=-1;
                }
        }

/* Spielzug bewerten. */

        for (i=0;i<24;i++){
                        for (j=0;j<24;j++){
                                if (SpielzugSpezial[i*24+j]->BeginnPosition->Zustand==0||SpielzugSpezial[i*24+j]->EndPosition->Zustand!=0||i==j){
                                SpielzugSpezial[i*24+j]->Bewertung=-1000;
                                }
                        }
        }      
        for (i=0;i<24*24;i++){
                if (SpielzugSpezial[i]->Bewertung<=-1000){
                        continue;
                }
                else{
                        Zustand_temp=SpielzugSpezial[i]->BeginnPosition->Zustand;
                        SpielzugSpezial[i]->BeginnPosition->Zustand=0;
                        SpielzugSpezial[i]->EndPosition->Zustand=Zustand_temp;
                        MuehleZustandZurueckSetzen();
                        MuehleZustandBerechnen();
			MuehleVIP[0]=SpielzugSpezial[i]->BeginnPosition->Muehle[0];
			MuehleVIP[1]=SpielzugSpezial[i]->BeginnPosition->Muehle[1];
			MuehleVIP[2]=SpielzugSpezial[i]->EndPosition->Muehle[0];
			MuehleVIP[3]=SpielzugSpezial[i]->EndPosition->Muehle[1];
			for (h=2;h<4;h++){
                        if (MeinMuehleZustand[MuehleVIP[h]]==3){
				SpielzugSpezial[i]->Bewertung+=50;
			}
			else if (GegnerMuehleZustand[MuehleVIP[h]]==2&&MuehleZustand[MuehleVIP[h]]==3){
				SpielzugSpezial[i]->Bewertung+=10;
                        }
			else if (MeinMuehleZustand[MuehleVIP[h]]==2&&GegnerMuehleZustand[MuehleVIP[h]]==0){
				SpielzugSpezial[i]->Bewertung+=2;	
			}
			else if (MeinMuehleZustand[MuehleVIP[h]]==1&&GegnerMuehleZustand[MuehleVIP[h]]==0){
				SpielzugSpezial[i]->Bewertung+=1;	
			}
                        else{
				continue;
			}
			}
			for (h=0;h<2;h++){
				if (GegnerMuehleZustand[MuehleVIP[h]]==2&&MuehleZustand[MuehleVIP[h]]==2){
                                        SpielzugSpezial[i]->Bewertung-=10;
                                }
				else if (MeinMuehleZustand[MuehleVIP[h]]==1&&GegnerMuehleZustand[MuehleVIP[h]]==0){
					SpielzugSpezial[i]->Bewertung-=2;	
				}
				else if (MeinMuehleZustand[MuehleVIP[h]]==1&&GegnerMuehleZustand[MuehleVIP[h]]==0){
					SpielzugSpezial[i]->Bewertung-=1;	
				}
                                else{
                                        continue;
                                }
			}
                        SpielzugSpezial[i]->EndPosition->Zustand=0;
                        SpielzugSpezial[i]->BeginnPosition->Zustand=Zustand_temp;
                }
        }

/* Spielzug mit der besten Bewertung finden. */

        BestBewertung=SpielzugSpezial[0]->Bewertung;
        for (i=0;i<24*24;i++){
                if (SpielzugSpezial[i]->Bewertung>BestBewertung){
                        BestBewertung=SpielzugSpezial[i]->Bewertung;
                }
        }
        j=0;//Zaehlen, wie viele Spielzuege mit der besten Bewertung gibt.
        for (i=0;i<24*24;i++){
                if (SpielzugSpezial[i]->Bewertung==BestBewertung){
                        SpielzugSpezial[i]->WahlHilfe=j;
                        j++;
                }      
        }
        srand(time(NULL)); 
        WahlNummer=rand()%j;
        for (i=0;i<24*24;i++){
                if (SpielzugSpezial[i]->WahlHilfe==WahlNummer){
                        NaechstenSpielzug=SpielzugSpezial[i];
                }
        }
}

void SteinEntfernen1(){
        int i,j,h;
        int GegnerSteinBewertung[24];
        int BestGegnerStein;
        int WahlNummer;
	int WahlArray[24];
	int MuehleVIP[2];
        for (i=0;i<24;i++){
                GegnerSteinBewertung[i]=0;
        }
        for (i=0;i<24;i++){
		if (AlleKnoten[i]->Zustand!=GegnerZustand){
			GegnerSteinBewertung[i]=-1000;
		}
		else{
			AlleKnoten[i]->Zustand=0;
			MuehleZustandZurueckSetzen();
			MuehleZustandBerechnen();
			MuehleVIP[0]=AlleKnoten[i]->Muehle[0];
			MuehleVIP[1]=AlleKnoten[i]->Muehle[1];
			for (h=0;h<2;h++){
				if (GegnerMuehleZustand[MuehleVIP[h]]==2&&MeinMuehleZustand[MuehleVIP[h]]==0){
					GegnerSteinBewertung[i]-=50;
				}      
				else if (GegnerMuehleZustand[MuehleVIP[h]]==1&&MeinMuehleZustand[MuehleVIP[h]]==0){
					GegnerSteinBewertung[i]+=50;
				}     
				else if (GegnerMuehleZustand[MuehleVIP[h]]==0&&MeinMuehleZustand[MuehleVIP[h]]==2){
					GegnerSteinBewertung[i]+=10;
				}
			}
			AlleKnoten[i]->Zustand=GegnerZustand;
		}
	}
       
/* Waehlen den zu entfernenden Stein.*/

                j=0;
                BestGegnerStein=GegnerSteinBewertung[0];
                for (i=0;i<24;i++){
			printf("points: %i\n",GegnerSteinBewertung[i]);
		}
		printf("best: %i\n",BestGegnerStein);
                for (i=0;i<24;i++){
                        if (GegnerSteinBewertung[i]>BestGegnerStein){
                                BestGegnerStein=GegnerSteinBewertung[i];
                        }
                }
                for (i=0;i<24;i++){
                        if (GegnerSteinBewertung[i]==BestGegnerStein){
                                WahlArray[j]=i;
                                j++;
                        }      
                }
		printf("J is %i\n",j);
                srand(time(NULL));
	    	WahlNummer=rand()%j;
		printf("WahlNummer is %i\n",WahlNummer);
		printf("array number is %i\n",WahlArray[WahlNummer]);
                ZuSchlagendenStein->Eins=AlleKnoten[WahlArray[WahlNummer]];
                printf("Entfernen %s\n",ZuSchlagendenStein->Eins->Name);
}

void SteinEntfernen2(){
        int i,j,h;
        int BestGegnerStein;
        int WahlNummer;
	int MuehleVIP[4];
/* Zu schlagenden Steine bewerten.*/

	for (i=0;i<24;i++){
		for (j=0;j<24;j++){
			if (AlleZSStein[i*24+j]->Eins->Zustand!=GegnerZustand||AlleZSStein[i*24+j]->Zwei->Zustand!=GegnerZustand||i==j){
				AlleZSStein[i]->Bewertung=-1000;
			}
			else{
				AlleZSStein[i*24+j]->Eins->Zustand=0;
				AlleZSStein[i*24+j]->Zwei->Zustand=0;
				MuehleZustandZurueckSetzen();
				MuehleZustandBerechnen();
				MuehleVIP[0]=AlleZSStein[i*24+j]->Eins->Muehle[0];
				MuehleVIP[1]=AlleZSStein[i*24+j]->Eins->Muehle[1];
				MuehleVIP[2]=AlleZSStein[i*24+j]->Zwei->Muehle[0];
				MuehleVIP[2]=AlleZSStein[i*24+j]->Zwei->Muehle[1];
				for (h=0;h<4;h++){
				if (GegnerMuehleZustand[MuehleVIP[h]]==2&&MeinMuehleZustand[MuehleVIP[h]]==0){
					AlleZSStein[i*24+j]->Bewertung-=50;
				}      
				else if (GegnerMuehleZustand[MuehleVIP[h]]==1&&MeinMuehleZustand[MuehleVIP[h]]==0){
					AlleZSStein[i*24+j]->Bewertung+=50;
				}     
				else if (GegnerMuehleZustand[MuehleVIP[h]]==0&&MeinMuehleZustand[MuehleVIP[h]]==2){
					AlleZSStein[i*24+j]->Bewertung+=10;
				}
				}
                	        AlleZSStein[i*24+j]->Eins->Zustand=GegnerZustand;
                        	AlleZSStein[i*24+j]->Zwei->Zustand=GegnerZustand;
                                }
                        }      

/* Zu schlagenden Steine waehlen. */

                j=0;
                BestGegnerStein=AlleZSStein[0]->Bewertung;
                for (i=0;i<24*24;i++){
                        if (AlleZSStein[i]->Bewertung>BestGegnerStein){
                                BestGegnerStein=AlleZSStein[i]->Bewertung;
                        }
                }
                for (i=0;i<24*24;i++){
                        if (AlleZSStein[i]->Bewertung==BestGegnerStein){
                                AlleZSStein[i]->WahlHilfe=j;
                                j++;
                        }      
                }
                srand(time(NULL));
	        WahlNummer=rand()%j;
                for (i=0;i<24*24;i++){
                        if (AlleZSStein[i]->WahlHilfe==WahlNummer){
                                ZuSchlagendenStein=AlleZSStein[i];
                        }
                }
                printf("Entfernen %s und %s.\n",ZuSchlagendenStein->Eins->Name,ZuSchlagendenStein->Zwei->Name);
        }
}



